package com.shitou.springai1.admin.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.shitou.springai1.admin.entity.dto.ImageDto;
import com.shitou.springai1.admin.entity.vo.ImagesVo;
import com.shitou.springai1.admin.service.impl.ImagesServiceImpl;
import lombok.RequiredArgsConstructor;
import org.codehaus.groovy.transform.SourceURIASTTransformation;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@PreAuthorize("hasRole('ADMIN')")
@RequestMapping("/api/admin/")
@RequiredArgsConstructor
public class ImagesController {

    //图片的地址
    private static final String IMAGE_URL = "src/main/resources/static/imagesAdmin/";
    private final ImagesServiceImpl imagesService;


    /*
    * 上传图片
    * @param imagesVo
    * @return
    * */
    @PostMapping("/images")
    public ResponseEntity upload(@RequestBody ImagesVo imagesVo) {
        // 1. 检查请求体是否包含所有必需的字段
        if (imagesVo.getImagesName() == null ||
                imagesVo.getDescription() == null ||
                imagesVo.getKeywords() == null ||
                imagesVo.getKeywords().isEmpty() ||
                imagesVo.getImagesFile() == null ||
                imagesVo.getImagesFile().isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body("图片名称、图片描述、关键词不能为空，图片文件不能为空");
        }

        try {
            // 2. 确保目录存在
            File directory = new File(IMAGE_URL);
            if (!directory.exists()) {
                directory.mkdirs();
            }

            // 3. 处理文件名和扩展名
            String originalFilename = imagesVo.getImagesName().trim();
            if (originalFilename.isEmpty()) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("文件名不能为空");
            }

            // 获取文件扩展名，如果没有则使用.jpg
            int lastDotIndex = originalFilename.lastIndexOf(".");
            String fileExtension = lastDotIndex > 0 ?
                    originalFilename.substring(lastDotIndex) : ".jpg";
            String nameWithoutExtension = lastDotIndex > 0 ?
                    originalFilename.substring(0, lastDotIndex) : originalFilename;

            // 生成新的文件名
            String newFileName = System.currentTimeMillis() + "_" + nameWithoutExtension + fileExtension;
            String filePath = IMAGE_URL + newFileName;

            // 4. 保存文件
            byte[] fileBytes = Base64.getDecoder().decode(imagesVo.getImagesFile().get(0));
            Files.write(Paths.get(filePath), fileBytes);

            // 5. 保存到数据库
            if (imagesService.saveImage(ImageDto.builder()
                    .imagesName(imagesVo.getImagesName())
                    .imagesUrl(filePath)
                    .description(imagesVo.getDescription())
                    .keywords(imagesVo.getKeywords())
                    .build())) {
                return ResponseEntity.ok("上传成功");
            } else {
                Files.deleteIfExists(Paths.get(filePath));
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("上传失败");
            }

        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body("图片数据格式不正确");
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("文件保存失败");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("服务器处理请求时发生错误");
        }
    }

    /* ⑨ 获取图片列表
    * @param pageNum
    * @param pageSize
    * @param keyword
    * @return
    * */
    @GetMapping("/images")
    public ResponseEntity<?> getImages(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "6") int pageSize,
            @RequestParam(required = false) String keyword) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        System.out.println("权限是：" + auth.getAuthorities());
        try {
            List<Map<String, Object>> images = imagesService.getImages(pageNum, pageSize, keyword);
            // 构建前端需要的分页格式（包含total和records，与前端loadTable函数适配）
            Map<String, Object> response = new HashMap<>();
            response.put("total", imagesService.count(
                    keyword != null && !keyword.trim().isEmpty() ?
                            new QueryWrapper<ImageDto>()
                                    .like("images_name", keyword.trim())
                                    .or()
                                    .like("description", keyword.trim()) : null
            )); // 总记录数
            response.put("records", images); // 当前页数据
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            // 关键：打印异常堆栈，定位真实错误（生产环境建议用日志框架，如SLF4J）
            e.printStackTrace();
            // 返回具体错误信息（便于前端调试，生产环境可隐藏详细信息）
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("服务器处理请求时发生错误：" + e.getMessage());
        }
    }

    /*
    * 编辑图片
    *
    * */
    @GetMapping("/images/{id}")
    public ResponseEntity<?> editImage(@PathVariable int id) {
        try {
            if (id == 0) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("图片ID不能为空");
            }
                // 更新成功后，返回更新后的图片信息
                ImageDto updatedImage = imagesService.getByIdWithKeywords(id);
                String url= updatedImage.getImagesUrl();
                System.out.println("图片地址是1：" + url);
                return ResponseEntity.ok(updatedImage);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("服务器处理请求时发生错误：" + e.getMessage());
        }
        }
    @PutMapping("/images/{id}")
    public ResponseEntity<?> updateImage(@PathVariable int id, @RequestBody ImagesVo imagesVo) {
        System.out.println("请求体内容是：" + imagesVo.getImagesUrl());
        System.out.println("图片的名字是：" + imagesVo.getImagesName());

        // 1. 检查请求体是否包含所有必需的字段
        if (imagesVo.getImagesName() == null ||
                imagesVo.getDescription() == null ||
                imagesVo.getKeywords() == null ||
                imagesVo.getKeywords().isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body("图片名称、图片描述、关键词不能为空");
        }

        try {
            // 获取原始图片信息
            ImageDto originalImage = imagesService.getById(id);
            if (originalImage == null) {
                return ResponseEntity.status(HttpStatus.NOT_FOUND)
                        .body("找不到ID为" + id + "的图片记录");
            }

            // 处理文件名和扩展名
            String originalFilename = imagesVo.getImagesName().trim();
            if (originalFilename.isEmpty()) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("文件名不能为空");
            }

            // 获取文件扩展名，如果没有则使用.jpg
            int lastDotIndex = originalFilename.lastIndexOf(".");
            String fileExtension = lastDotIndex > 0 ?
                    originalFilename.substring(lastDotIndex) : ".jpg";
            String nameWithoutExtension = lastDotIndex > 0 ?
                    originalFilename.substring(0, lastDotIndex) : originalFilename;

            // 判断是否有新图片上传
            boolean hasNewImage = imagesVo.getImagesFile() != null &&
                    !imagesVo.getImagesFile().isEmpty() &&
                    imagesVo.getImagesFile().get(0) != null &&
                    !imagesVo.getImagesFile().get(0).isEmpty();

            String filePath;
            if (hasNewImage) {
                // 有新图片上传，保存新图片
                File directory = new File(IMAGE_URL);
                if (!directory.exists()) {
                    directory.mkdirs();
                }

                // 生成新的文件名
                String newFileName = System.currentTimeMillis() + "_" + nameWithoutExtension + fileExtension;
                filePath = IMAGE_URL + newFileName;

                // 保存文件
                byte[] fileBytes = Base64.getDecoder().decode(imagesVo.getImagesFile().get(0));
                Files.write(Paths.get(filePath), fileBytes);

                // 删除旧图片文件（可选）
                if (originalImage.getImagesUrl() != null && !originalImage.getImagesUrl().isEmpty()) {
                    try {
                        Files.deleteIfExists(Paths.get(originalImage.getImagesUrl()));
                    } catch (IOException e) {
                        System.err.println("删除旧图片文件失败: " + e.getMessage());
                    }
                }
            } else {
                // 没有新图片上传，保留原图片路径
                filePath = originalImage.getImagesUrl();
            }

            // 更新数据库记录
            imagesVo.setImagesUrl(filePath);
            if (imagesService.updateImage(id, imagesVo)) {
                return ResponseEntity.ok("更新成功");
            } else {
                // 如果更新失败且保存了新文件，删除新文件（可选）
                if (hasNewImage) {
                    try {
                        Files.deleteIfExists(Paths.get(filePath));
                    } catch (IOException e) {
                        System.err.println("删除新图片文件失败: " + e.getMessage());
                    }
                }
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("更新失败");
            }
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("服务器处理请求时发生错误：" + e.getMessage());
        }
    }



    /*
    *
    * 删除图片
    * @param id
    * @return
    * */
    @DeleteMapping("/images/{id}")
    public ResponseEntity<?> deleteImage(@PathVariable int id) {
        try {
            if (id == 0) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("图片ID不能为空");
            }
            // 删除成功后，返回删除成功信息
            if (imagesService.removeById(id)) {
                return ResponseEntity.ok("删除成功");
            } else {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body("删除失败");
            }
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("服务器处理请求时发生错误：" + e.getMessage());
        }
    }
    }
